

\section{线程和队列 }\label{ux7ebfux7a0bux548cux961fux5217}

在使用TensorFlow进行异步计算时，队列是一种强大的机制。

正如TensorFlow中的其他组件一样，队列就是TensorFlow图中的节点。这是一种有状态的节点，就像变量一样：其他节点可以修改它的内容。具体来说，其他节点可以把新元素插入到队列后端(rear)，也可以把队列前端(front)的元素删除。

为了感受一下队列，让我们来看一个简单的例子。我们先创建一个``先入先出''的队列（FIFOQueue），并将其内部所有元素初始化为零。然后，我们构建一个TensorFlow图，它从队列前端取走一个元素，加上1之后，放回队列的后端。慢慢地，队列的元素的值就会增加。

\texttt{Enqueue}、
\texttt{EnqueueMany}和\texttt{Dequeue}都是特殊的节点。他们需要获取队列指针，而非普通的值，如此才能修改队列内容。我们建议您将它们看作队列的方法。事实上，在Python
API中，它们就是队列对象的方法（例如\texttt{q.enqueue(...)}）。

现在你已经对队列有了一定的了解，让我们深入到细节\ldots{}

\subsection{队列使用概述 }\label{ux961fux5217ux4f7fux7528ux6982ux8ff0}

队列，如\texttt{FIFOQueue}和\texttt{RandomShuffleQueue}，在TensorFlow的张量异步计算时都非常重要。

例如，一个典型的输入结构：是使用一个\texttt{RandomShuffleQueue}来作为模型训练的输入：

\begin{itemize}
\tightlist
\item
  多个线程准备训练样本，并且把这些样本推入队列。
\item
  一个训练线程执行一个训练操作，此操作会从队列中移除最小批次的样本（mini-batches)。
\end{itemize}

这种结构具有许多优点，正如在\href{../reading_data}{Reading data how
to}中强调的，同时，\href{../reading_data}{Reading data how
to}也概括地描述了如何简化输入管道的构造过程。

TensorFlow的\texttt{Session}对象是可以支持多线程的，因此多个线程可以很方便地使用同一个会话（Session）并且并行地执行操作。然而，在Python程序实现这样的并行运算却并不容易。所有线程都必须能被同步终止，异常必须能被正确捕获并报告，回话终止的时候，
队列必须能被正确地关闭。

所幸TensorFlow提供了两个类来帮助多线程的实现：\href{tensorflow-zh/SOURCE/api_docs/python/train.md\#Coordinator}{tf.Coordinator}和
\href{tensorflow-zh/SOURCE/api_docs/python/train.md\#QueueRunner}{tf.QueueRunner}。从设计上这两个类必须被一起使用。\texttt{Coordinator}类可以用来同时停止多个工作线程并且向那个在等待所有工作线程终止的程序报告异常。\texttt{QueueRunner}类用来协调多个工作线程同时将多个张量推入同一个队列中。

\subsection{Coordinator }\label{coordinator}

Coordinator类用来帮助多个线程协同工作，多个线程同步终止。 其主要方法有：

\begin{itemize}
\tightlist
\item
  \texttt{should\_stop()}:如果线程应该停止则返回True。
\item
  \texttt{request\_stop(\textless{}exception\textgreater{})}:
  请求该线程停止。
\item
  \texttt{join(\textless{}list\ of\ threads\textgreater{})}:等待被指定的线程终止。
\end{itemize}

首先创建一个\texttt{Coordinator}对象，然后建立一些使用\texttt{Coordinator}对象的线程。这些线程通常一直循环运行，一直到\texttt{should\_stop()}返回True时停止。
任何线程都可以决定计算什么时候应该停止。它只需要调用\texttt{request\_stop()}，同时其他线程的\texttt{should\_stop()}将会返回\texttt{True}，然后都停下来。

\begin{Shaded}
\begin{Highlighting}[]
\CommentTok{# 线程体：循环执行，直到`Coordinator`收到了停止请求。}
\CommentTok{# 如果某些条件为真，请求`Coordinator`去停止其他线程。}
\KeywordTok{def} \NormalTok{MyLoop(coord):}
  \ControlFlowTok{while} \OperatorTok{not} \NormalTok{coord.should_stop():}
    \NormalTok{...do something...}
    \ControlFlowTok{if} \NormalTok{...some condition...:}
      \NormalTok{coord.request_stop()}

\CommentTok{# Main code: create a coordinator.}
\NormalTok{coord }\OperatorTok{=} \NormalTok{Coordinator()}

\CommentTok{# Create 10 threads that run 'MyLoop()'}
\NormalTok{threads }\OperatorTok{=} \NormalTok{[threading.Thread(target}\OperatorTok{=}\NormalTok{MyLoop, args}\OperatorTok{=}\NormalTok{(coord)) }\ControlFlowTok{for} \NormalTok{i }\OperatorTok{in} \BuiltInTok{xrange}\NormalTok{(}\DecValTok{10}\NormalTok{)]}

\CommentTok{# Start the threads and wait for all of them to stop.}
\ControlFlowTok{for} \NormalTok{t }\OperatorTok{in} \NormalTok{threads: t.start()}
\NormalTok{coord.join(threads)}
\end{Highlighting}
\end{Shaded}

显然，Coordinator可以管理线程去做不同的事情。上面的代码只是一个简单的例子，在设计实现的时候不必完全照搬。Coordinator还支持捕捉和报告异常,
具体可以参考\href{tensorflow-zh/SOURCE/api_docs/python/train.md\#Coordinator}{Coordinator
class}的文档。

\subsection{QueueRunner }\label{queuerunner}

\texttt{QueueRunner}类会创建一组线程，
这些线程可以重复的执行Enquene操作，
他们使用同一个Coordinator来处理线程同步终止。此外，一个QueueRunner会运行一个\emph{closer
thread}，当Coordinator收到异常报告时，这个\emph{closer
thread}会自动关闭队列。

您可以使用一个queue runner，来实现上述结构。
首先建立一个TensorFlow图表，这个图表使用队列来输入样本。增加处理样本并将样本推入队列中的操作。增加training操作来移除队列中的样本。

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{example }\OperatorTok{=} \NormalTok{...ops to create one example...}
\CommentTok{# Create a queue, and an op that enqueues examples one at a time in the queue.}
\NormalTok{queue }\OperatorTok{=} \NormalTok{tf.RandomShuffleQueue(...)}
\NormalTok{enqueue_op }\OperatorTok{=} \NormalTok{queue.enqueue(example)}
\CommentTok{# Create a training graph that starts by dequeuing a batch of examples.}
\NormalTok{inputs }\OperatorTok{=} \NormalTok{queue.dequeue_many(batch_size)}
\NormalTok{train_op }\OperatorTok{=} \NormalTok{...use }\StringTok{'inputs'} \NormalTok{to build the training part of the graph...}
\end{Highlighting}
\end{Shaded}

在Python的训练程序中，创建一个\texttt{QueueRunner}来运行几个线程，
这几个线程处理样本，并且将样本推入队列。创建一个\texttt{Coordinator}，让queue
runner使用\texttt{Coordinator}来启动这些线程，创建一个训练的循环，
并且使用\texttt{Coordinator}来控制\texttt{QueueRunner}的线程们的终止。

\begin{verbatim}
# Create a queue runner that will run 4 threads in parallel to enqueue
# examples.
qr = tf.train.QueueRunner(queue, [enqueue_op] * 4)

# Launch the graph.
sess = tf.Session()
# Create a coordinator, launch the queue runner threads.
coord = tf.train.Coordinator()
enqueue_threads = qr.create_threads(sess, coord=coord, start=True)
# Run the training loop, controlling termination with the coordinator.
for step in xrange(1000000):
    if coord.should_stop():
        break
    sess.run(train_op)
# When done, ask the threads to stop.
coord.request_stop()
# And wait for them to actually do it.
coord.join(threads)
\end{verbatim}

\subsection{异常处理 }\label{ux5f02ux5e38ux5904ux7406}

通过queue
runners启动的线程不仅仅只处理推送样本到队列。他们还捕捉和处理由队列产生的异常，包括\texttt{OutOfRangeError}异常，这个异常是用于报告队列被关闭。
使用\texttt{Coordinator}的训练程序在主循环中必须同时捕捉和报告异常。
下面是对上面训练循环的改进版本。

\begin{Shaded}
\begin{Highlighting}[]
\ControlFlowTok{try}\NormalTok{:}
    \ControlFlowTok{for} \NormalTok{step }\OperatorTok{in} \BuiltInTok{xrange}\NormalTok{(}\DecValTok{1000000}\NormalTok{):}
        \ControlFlowTok{if} \NormalTok{coord.should_stop():}
            \ControlFlowTok{break}
        \NormalTok{sess.run(train_op)}
\ControlFlowTok{except} \PreprocessorTok{Exception}\NormalTok{, e:}
   \CommentTok{# Report exceptions to the coordinator.}
   \NormalTok{coord.request_stop(e)}

\CommentTok{# Terminate as usual.  It is innocuous to request stop twice.}
\NormalTok{coord.request_stop()}
\NormalTok{coord.join(threads)}
\end{Highlighting}
\end{Shaded}

原文地址：\href{https://github.com/jikexueyuanwiki/tensorflow-zh/blob/master/SOURCE/how_tos/threading_and_queues/index.md}{Threading
and Queues} 翻译：\href{https://github.com/zhangkom}{zhangkom}
校对：\href{https://github.com/volvet}{volvet}


